// $ANTLR 3.1.1 LPMEDLexer.g 2009-10-05 23:27:25
// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162
namespace  Core.ANTLRGrammars 
{

using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;


/***************************************************************
****************************************************************
*****  Language for Parallel Management of External Devices*****
****************************************************************
***************************************************************/
public partial class LPMEDLexer : Lexer {
    public const int OpIncDec = 40;
    public const int WHILE = 60;
    public const int OpLogicalA = 45;
    public const int OpAnd = 47;
    public const int OBJECTNAME = 25;
    public const int OpLogicalB = 46;
    public const int CPROGRAM = 4;
    public const int CTYPE = 6;
    public const int OpNegation = 41;
    public const int DBOOL = 50;
    public const int FOR = 59;
    public const int PARAM = 38;
    public const int EQUALS = 75;
    public const int FLOAT = 55;
    public const int OpAddSub = 44;
    public const int CURLYCBRACKET = 74;
    public const int LINECOMMENT = 69;
    public const int ID = 70;
    public const int EOF = -1;
    public const int CASYNCCALL = 21;
    public const int CSYNCFUNCCALL = 34;
    public const int IF = 56;
    public const int TYPE = 49;
    public const int CIFTE = 9;
    public const int CWAITANYCALL = 23;
    public const int CWAITFUNCFINISH = 35;
    public const int THEN = 57;
    public const int CFORDEC = 13;
    public const int COMMA = 79;
    public const int OpDivMul = 43;
    public const int CDEVICE = 5;
    public const int CURLYOBRACKET = 73;
    public const int CSYNCCALL = 20;
    public const int CFOR = 12;
    public const int DEVICE = 51;
    public const int NODES = 27;
    public const int VAR = 64;
    public const int CREGFUNCACCESS = 31;
    public const int ENDDEVICE = 53;
    public const int DOT = 76;
    public const int CMETHODNAME = 15;
    public const int CBRACKET = 72;
    public const int MEMBERNAME = 26;
    public const int PARAMS = 37;
    public const int CWHILE = 11;
    public const int STATE = 52;
    public const int DEFUN = 66;
    public const int OpUnar = 42;
    public const int CREGMETHACCESS = 30;
    public const int CTERMINATEALL = 32;
    public const int ELSE = 58;
    public const int CDEFUN = 36;
    public const int CUNARMIN = 14;
    public const int CSTATEMENT = 8;
    public const int INT = 54;
    public const int WAIT = 61;
    public const int SEMI = 77;
    public const int CASSIGN = 10;
    public const int COLON = 78;
    public const int CBREAKPOINT = 29;
    public const int CINT = 17;
    public const int WS = 67;
    public const int NEWLINE = 68;
    public const int CENDTHECALL = 24;
    public const int TERMINATEALL = 39;
    public const int OpOr = 48;
    public const int ENDPRESSURE = 63;
    public const int CCALL = 16;
    public const int CBLOCK = 7;
    public const int OBRACKET = 71;
    public const int GO = 62;
    public const int CGETSTATE = 28;
    public const int CASYNCFUNCCALL = 33;
    public const int CBOOL = 19;
    public const int CFLOAT = 18;
    public const int BREAKPOINT = 65;
    public const int CWAITTHECALL = 22;

    // delegates
    // delegators

    public LPMEDLexer() 
    {
		InitializeCyclicDFAs();
    }
    public LPMEDLexer(ICharStream input)
		: this(input, null) {
    }
    public LPMEDLexer(ICharStream input, RecognizerSharedState state)
		: base(input, state) {
		InitializeCyclicDFAs(); 

    }
    
    override public string GrammarFileName
    {
    	get { return "LPMEDLexer.g";} 
    }

    // $ANTLR start "TERMINATEALL"
    public void mTERMINATEALL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = TERMINATEALL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:59:17: ( 'terminate_all' )
            // LPMEDLexer.g:59:19: 'terminate_all'
            {
            	Match("terminate_all"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "TERMINATEALL"

    // $ANTLR start "OpIncDec"
    public void mOpIncDec() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = OpIncDec;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:61:13: ( '++' | '--' )
            int alt1 = 2;
            int LA1_0 = input.LA(1);

            if ( (LA1_0 == '+') )
            {
                alt1 = 1;
            }
            else if ( (LA1_0 == '-') )
            {
                alt1 = 2;
            }
            else 
            {
                NoViableAltException nvae_d1s0 =
                    new NoViableAltException("", 1, 0, input);

                throw nvae_d1s0;
            }
            switch (alt1) 
            {
                case 1 :
                    // LPMEDLexer.g:61:15: '++'
                    {
                    	Match("++"); 


                    }
                    break;
                case 2 :
                    // LPMEDLexer.g:61:20: '--'
                    {
                    	Match("--"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "OpIncDec"

    // $ANTLR start "OpNegation"
    public void mOpNegation() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = OpNegation;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:62:13: ( '!' | 'not' )
            int alt2 = 2;
            int LA2_0 = input.LA(1);

            if ( (LA2_0 == '!') )
            {
                alt2 = 1;
            }
            else if ( (LA2_0 == 'n') )
            {
                alt2 = 2;
            }
            else 
            {
                NoViableAltException nvae_d2s0 =
                    new NoViableAltException("", 2, 0, input);

                throw nvae_d2s0;
            }
            switch (alt2) 
            {
                case 1 :
                    // LPMEDLexer.g:62:15: '!'
                    {
                    	Match('!'); 

                    }
                    break;
                case 2 :
                    // LPMEDLexer.g:62:19: 'not'
                    {
                    	Match("not"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "OpNegation"

    // $ANTLR start "OpUnar"
    public void mOpUnar() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = OpUnar;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:63:13: ( '-' )
            // LPMEDLexer.g:63:15: '-'
            {
            	Match('-'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "OpUnar"

    // $ANTLR start "OpDivMul"
    public void mOpDivMul() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = OpDivMul;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:64:13: ( '*' | '/' )
            // LPMEDLexer.g:
            {
            	if ( input.LA(1) == '*' || input.LA(1) == '/' ) 
            	{
            	    input.Consume();

            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    Recover(mse);
            	    throw mse;}


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "OpDivMul"

    // $ANTLR start "OpAddSub"
    public void mOpAddSub() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = OpAddSub;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:65:13: ( '+' | '-' )
            // LPMEDLexer.g:
            {
            	if ( input.LA(1) == '+' || input.LA(1) == '-' ) 
            	{
            	    input.Consume();

            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    Recover(mse);
            	    throw mse;}


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "OpAddSub"

    // $ANTLR start "OpLogicalA"
    public void mOpLogicalA() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = OpLogicalA;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:66:13: ( '<' | '<=' | '>' | '>=' )
            int alt3 = 4;
            int LA3_0 = input.LA(1);

            if ( (LA3_0 == '<') )
            {
                int LA3_1 = input.LA(2);

                if ( (LA3_1 == '=') )
                {
                    alt3 = 2;
                }
                else 
                {
                    alt3 = 1;}
            }
            else if ( (LA3_0 == '>') )
            {
                int LA3_2 = input.LA(2);

                if ( (LA3_2 == '=') )
                {
                    alt3 = 4;
                }
                else 
                {
                    alt3 = 3;}
            }
            else 
            {
                NoViableAltException nvae_d3s0 =
                    new NoViableAltException("", 3, 0, input);

                throw nvae_d3s0;
            }
            switch (alt3) 
            {
                case 1 :
                    // LPMEDLexer.g:66:15: '<'
                    {
                    	Match('<'); 

                    }
                    break;
                case 2 :
                    // LPMEDLexer.g:66:19: '<='
                    {
                    	Match("<="); 


                    }
                    break;
                case 3 :
                    // LPMEDLexer.g:66:24: '>'
                    {
                    	Match('>'); 

                    }
                    break;
                case 4 :
                    // LPMEDLexer.g:66:28: '>='
                    {
                    	Match(">="); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "OpLogicalA"

    // $ANTLR start "OpLogicalB"
    public void mOpLogicalB() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = OpLogicalB;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:67:13: ( '==' | '~=' )
            int alt4 = 2;
            int LA4_0 = input.LA(1);

            if ( (LA4_0 == '=') )
            {
                alt4 = 1;
            }
            else if ( (LA4_0 == '~') )
            {
                alt4 = 2;
            }
            else 
            {
                NoViableAltException nvae_d4s0 =
                    new NoViableAltException("", 4, 0, input);

                throw nvae_d4s0;
            }
            switch (alt4) 
            {
                case 1 :
                    // LPMEDLexer.g:67:15: '=='
                    {
                    	Match("=="); 


                    }
                    break;
                case 2 :
                    // LPMEDLexer.g:67:20: '~='
                    {
                    	Match("~="); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "OpLogicalB"

    // $ANTLR start "OpAnd"
    public void mOpAnd() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = OpAnd;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:68:13: ( '&&' | 'and' )
            int alt5 = 2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0 == '&') )
            {
                alt5 = 1;
            }
            else if ( (LA5_0 == 'a') )
            {
                alt5 = 2;
            }
            else 
            {
                NoViableAltException nvae_d5s0 =
                    new NoViableAltException("", 5, 0, input);

                throw nvae_d5s0;
            }
            switch (alt5) 
            {
                case 1 :
                    // LPMEDLexer.g:68:15: '&&'
                    {
                    	Match("&&"); 


                    }
                    break;
                case 2 :
                    // LPMEDLexer.g:68:20: 'and'
                    {
                    	Match("and"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "OpAnd"

    // $ANTLR start "OpOr"
    public void mOpOr() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = OpOr;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:69:13: ( '||' | 'or' )
            int alt6 = 2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0 == '|') )
            {
                alt6 = 1;
            }
            else if ( (LA6_0 == 'o') )
            {
                alt6 = 2;
            }
            else 
            {
                NoViableAltException nvae_d6s0 =
                    new NoViableAltException("", 6, 0, input);

                throw nvae_d6s0;
            }
            switch (alt6) 
            {
                case 1 :
                    // LPMEDLexer.g:69:15: '||'
                    {
                    	Match("||"); 


                    }
                    break;
                case 2 :
                    // LPMEDLexer.g:69:20: 'or'
                    {
                    	Match("or"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "OpOr"

    // $ANTLR start "TYPE"
    public void mTYPE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = TYPE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:71:9: ( 'int' | 'float' | 'bool' | 'string' )
            int alt7 = 4;
            switch ( input.LA(1) ) 
            {
            case 'i':
            	{
                alt7 = 1;
                }
                break;
            case 'f':
            	{
                alt7 = 2;
                }
                break;
            case 'b':
            	{
                alt7 = 3;
                }
                break;
            case 's':
            	{
                alt7 = 4;
                }
                break;
            	default:
            	    NoViableAltException nvae_d7s0 =
            	        new NoViableAltException("", 7, 0, input);

            	    throw nvae_d7s0;
            }

            switch (alt7) 
            {
                case 1 :
                    // LPMEDLexer.g:72:9: 'int'
                    {
                    	Match("int"); 


                    }
                    break;
                case 2 :
                    // LPMEDLexer.g:73:9: 'float'
                    {
                    	Match("float"); 


                    }
                    break;
                case 3 :
                    // LPMEDLexer.g:74:9: 'bool'
                    {
                    	Match("bool"); 


                    }
                    break;
                case 4 :
                    // LPMEDLexer.g:75:9: 'string'
                    {
                    	Match("string"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "TYPE"

    // $ANTLR start "DBOOL"
    public void mDBOOL() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = DBOOL;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:78:9: ( 'true' | 'false' )
            int alt8 = 2;
            int LA8_0 = input.LA(1);

            if ( (LA8_0 == 't') )
            {
                alt8 = 1;
            }
            else if ( (LA8_0 == 'f') )
            {
                alt8 = 2;
            }
            else 
            {
                NoViableAltException nvae_d8s0 =
                    new NoViableAltException("", 8, 0, input);

                throw nvae_d8s0;
            }
            switch (alt8) 
            {
                case 1 :
                    // LPMEDLexer.g:79:9: 'true'
                    {
                    	Match("true"); 


                    }
                    break;
                case 2 :
                    // LPMEDLexer.g:80:9: 'false'
                    {
                    	Match("false"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "DBOOL"

    // $ANTLR start "DEVICE"
    public void mDEVICE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = DEVICE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:83:9: ( 'DEVICE' )
            // LPMEDLexer.g:83:13: 'DEVICE'
            {
            	Match("DEVICE"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "DEVICE"

    // $ANTLR start "STATE"
    public void mSTATE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = STATE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:85:9: ( 'State' )
            // LPMEDLexer.g:85:11: 'State'
            {
            	Match("State"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "STATE"

    // $ANTLR start "ENDDEVICE"
    public void mENDDEVICE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = ENDDEVICE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:88:5: ( ( 'END' '.' ) )
            // LPMEDLexer.g:89:9: ( 'END' '.' )
            {
            	// LPMEDLexer.g:89:9: ( 'END' '.' )
            	// LPMEDLexer.g:89:10: 'END' '.'
            	{
            		Match("END"); 

            		Match('.'); 

            	}


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "ENDDEVICE"

    // $ANTLR start "INT"
    public void mINT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = INT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:92:9: ( ( '0' .. '9' )+ )
            // LPMEDLexer.g:93:9: ( '0' .. '9' )+
            {
            	// LPMEDLexer.g:93:9: ( '0' .. '9' )+
            	int cnt9 = 0;
            	do 
            	{
            	    int alt9 = 2;
            	    int LA9_0 = input.LA(1);

            	    if ( ((LA9_0 >= '0' && LA9_0 <= '9')) )
            	    {
            	        alt9 = 1;
            	    }


            	    switch (alt9) 
            		{
            			case 1 :
            			    // LPMEDLexer.g:93:10: '0' .. '9'
            			    {
            			    	MatchRange('0','9'); 

            			    }
            			    break;

            			default:
            			    if ( cnt9 >= 1 ) goto loop9;
            		            EarlyExitException eee =
            		                new EarlyExitException(9, input);
            		            throw eee;
            	    }
            	    cnt9++;
            	} while (true);

            	loop9:
            		;	// Stops C# compiler whinging that label 'loop9' has no statements


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "INT"

    // $ANTLR start "FLOAT"
    public void mFLOAT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = FLOAT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:96:9: ( INT '.' INT )
            // LPMEDLexer.g:97:9: INT '.' INT
            {
            	mINT(); 
            	Match('.'); 
            	mINT(); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "FLOAT"

    // $ANTLR start "IF"
    public void mIF() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = IF;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:100:4: ( 'if' )
            // LPMEDLexer.g:100:6: 'if'
            {
            	Match("if"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "IF"

    // $ANTLR start "THEN"
    public void mTHEN() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = THEN;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:101:6: ( 'then' )
            // LPMEDLexer.g:101:8: 'then'
            {
            	Match("then"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "THEN"

    // $ANTLR start "ELSE"
    public void mELSE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = ELSE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:102:6: ( 'else' )
            // LPMEDLexer.g:102:8: 'else'
            {
            	Match("else"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "ELSE"

    // $ANTLR start "FOR"
    public void mFOR() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = FOR;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:103:5: ( 'for' )
            // LPMEDLexer.g:103:7: 'for'
            {
            	Match("for"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "FOR"

    // $ANTLR start "WHILE"
    public void mWHILE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = WHILE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:104:7: ( 'while' )
            // LPMEDLexer.g:104:9: 'while'
            {
            	Match("while"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "WHILE"

    // $ANTLR start "WAIT"
    public void mWAIT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = WAIT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:105:7: ( 'wait' )
            // LPMEDLexer.g:105:9: 'wait'
            {
            	Match("wait"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "WAIT"

    // $ANTLR start "GO"
    public void mGO() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = GO;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:106:7: ( 'go' )
            // LPMEDLexer.g:106:9: 'go'
            {
            	Match("go"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "GO"

    // $ANTLR start "ENDPRESSURE"
    public void mENDPRESSURE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = ENDPRESSURE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:107:12: ( 'end' )
            // LPMEDLexer.g:107:13: 'end'
            {
            	Match("end"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "ENDPRESSURE"

    // $ANTLR start "VAR"
    public void mVAR() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = VAR;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:108:5: ( 'VAR' )
            // LPMEDLexer.g:108:7: 'VAR'
            {
            	Match("VAR"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "VAR"

    // $ANTLR start "BREAKPOINT"
    public void mBREAKPOINT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = BREAKPOINT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:110:11: ( 'Breakpoint' )
            // LPMEDLexer.g:110:13: 'Breakpoint'
            {
            	Match("Breakpoint"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "BREAKPOINT"

    // $ANTLR start "DEFUN"
    public void mDEFUN() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = DEFUN;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:112:6: ( 'defun' )
            // LPMEDLexer.g:112:8: 'defun'
            {
            	Match("defun"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "DEFUN"

    // $ANTLR start "WS"
    public void mWS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = WS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:114:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
            // LPMEDLexer.g:114:13: ( ' ' | '\\t' | '\\r' | '\\n' )+
            {
            	// LPMEDLexer.g:114:13: ( ' ' | '\\t' | '\\r' | '\\n' )+
            	int cnt10 = 0;
            	do 
            	{
            	    int alt10 = 2;
            	    int LA10_0 = input.LA(1);

            	    if ( ((LA10_0 >= '\t' && LA10_0 <= '\n') || LA10_0 == '\r' || LA10_0 == ' ') )
            	    {
            	        alt10 = 1;
            	    }


            	    switch (alt10) 
            		{
            			case 1 :
            			    // LPMEDLexer.g:
            			    {
            			    	if ( (input.LA(1) >= '\t' && input.LA(1) <= '\n') || input.LA(1) == '\r' || input.LA(1) == ' ' ) 
            			    	{
            			    	    input.Consume();

            			    	}
            			    	else 
            			    	{
            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    	    Recover(mse);
            			    	    throw mse;}


            			    }
            			    break;

            			default:
            			    if ( cnt10 >= 1 ) goto loop10;
            		            EarlyExitException eee =
            		                new EarlyExitException(10, input);
            		            throw eee;
            	    }
            	    cnt10++;
            	} while (true);

            	loop10:
            		;	// Stops C# compiler whinging that label 'loop10' has no statements

            	 _channel=HIDDEN; 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "WS"

    // $ANTLR start "NEWLINE"
    public void mNEWLINE() // throws RecognitionException [2]
    {
    		try
    		{
            // LPMEDLexer.g:123:17: ( '\\r' | '\\n' )
            // LPMEDLexer.g:
            {
            	if ( input.LA(1) == '\n' || input.LA(1) == '\r' ) 
            	{
            	    input.Consume();

            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    Recover(mse);
            	    throw mse;}


            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "NEWLINE"

    // $ANTLR start "LINECOMMENT"
    public void mLINECOMMENT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = LINECOMMENT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:126:13: ( '//' (~ ( '\\r' | '\\n' ) )* NEWLINE )
            // LPMEDLexer.g:126:17: '//' (~ ( '\\r' | '\\n' ) )* NEWLINE
            {
            	Match("//"); 

            	// LPMEDLexer.g:126:22: (~ ( '\\r' | '\\n' ) )*
            	do 
            	{
            	    int alt11 = 2;
            	    int LA11_0 = input.LA(1);

            	    if ( ((LA11_0 >= '\u0000' && LA11_0 <= '\t') || (LA11_0 >= '\u000B' && LA11_0 <= '\f') || (LA11_0 >= '\u000E' && LA11_0 <= '\uFFFF')) )
            	    {
            	        alt11 = 1;
            	    }


            	    switch (alt11) 
            		{
            			case 1 :
            			    // LPMEDLexer.g:126:22: ~ ( '\\r' | '\\n' )
            			    {
            			    	if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t') || (input.LA(1) >= '\u000B' && input.LA(1) <= '\f') || (input.LA(1) >= '\u000E' && input.LA(1) <= '\uFFFF') ) 
            			    	{
            			    	    input.Consume();

            			    	}
            			    	else 
            			    	{
            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    	    Recover(mse);
            			    	    throw mse;}


            			    }
            			    break;

            			default:
            			    goto loop11;
            	    }
            	} while (true);

            	loop11:
            		;	// Stops C# compiler whining that label 'loop11' has no statements

            	mNEWLINE(); 
            	_channel=HIDDEN;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "LINECOMMENT"

    // $ANTLR start "ID"
    public void mID() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = ID;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:129:9: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* )
            // LPMEDLexer.g:129:13: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
            {
            	if ( (input.LA(1) >= 'A' && input.LA(1) <= 'Z') || input.LA(1) == '_' || (input.LA(1) >= 'a' && input.LA(1) <= 'z') ) 
            	{
            	    input.Consume();

            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    Recover(mse);
            	    throw mse;}

            	// LPMEDLexer.g:129:41: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
            	do 
            	{
            	    int alt12 = 2;
            	    int LA12_0 = input.LA(1);

            	    if ( ((LA12_0 >= '0' && LA12_0 <= '9') || (LA12_0 >= 'A' && LA12_0 <= 'Z') || LA12_0 == '_' || (LA12_0 >= 'a' && LA12_0 <= 'z')) )
            	    {
            	        alt12 = 1;
            	    }


            	    switch (alt12) 
            		{
            			case 1 :
            			    // LPMEDLexer.g:
            			    {
            			    	if ( (input.LA(1) >= '0' && input.LA(1) <= '9') || (input.LA(1) >= 'A' && input.LA(1) <= 'Z') || input.LA(1) == '_' || (input.LA(1) >= 'a' && input.LA(1) <= 'z') ) 
            			    	{
            			    	    input.Consume();

            			    	}
            			    	else 
            			    	{
            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    	    Recover(mse);
            			    	    throw mse;}


            			    }
            			    break;

            			default:
            			    goto loop12;
            	    }
            	} while (true);

            	loop12:
            		;	// Stops C# compiler whining that label 'loop12' has no statements


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "ID"

    // $ANTLR start "OBRACKET"
    public void mOBRACKET() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = OBRACKET;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:131:13: ( '(' )
            // LPMEDLexer.g:131:15: '('
            {
            	Match('('); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "OBRACKET"

    // $ANTLR start "CBRACKET"
    public void mCBRACKET() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = CBRACKET;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:133:13: ( ')' )
            // LPMEDLexer.g:133:15: ')'
            {
            	Match(')'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "CBRACKET"

    // $ANTLR start "CURLYOBRACKET"
    public void mCURLYOBRACKET() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = CURLYOBRACKET;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:135:17: ( '{' )
            // LPMEDLexer.g:135:19: '{'
            {
            	Match('{'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "CURLYOBRACKET"

    // $ANTLR start "CURLYCBRACKET"
    public void mCURLYCBRACKET() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = CURLYCBRACKET;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:137:17: ( '}' )
            // LPMEDLexer.g:137:19: '}'
            {
            	Match('}'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "CURLYCBRACKET"

    // $ANTLR start "EQUALS"
    public void mEQUALS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = EQUALS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:139:13: ( '=' )
            // LPMEDLexer.g:139:15: '='
            {
            	Match('='); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "EQUALS"

    // $ANTLR start "DOT"
    public void mDOT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = DOT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:141:9: ( '.' )
            // LPMEDLexer.g:141:11: '.'
            {
            	Match('.'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "DOT"

    // $ANTLR start "SEMI"
    public void mSEMI() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = SEMI;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:143:13: ( ';' )
            // LPMEDLexer.g:143:15: ';'
            {
            	Match(';'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "SEMI"

    // $ANTLR start "COLON"
    public void mCOLON() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = COLON;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:145:13: ( ':' )
            // LPMEDLexer.g:145:15: ':'
            {
            	Match(':'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "COLON"

    // $ANTLR start "COMMA"
    public void mCOMMA() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = COMMA;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // LPMEDLexer.g:147:13: ( ',' )
            // LPMEDLexer.g:147:15: ','
            {
            	Match(','); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "COMMA"

    override public void mTokens() // throws RecognitionException 
    {
        // LPMEDLexer.g:1:8: ( TERMINATEALL | OpIncDec | OpNegation | OpUnar | OpDivMul | OpAddSub | OpLogicalA | OpLogicalB | OpAnd | OpOr | TYPE | DBOOL | DEVICE | STATE | ENDDEVICE | INT | FLOAT | IF | THEN | ELSE | FOR | WHILE | WAIT | GO | ENDPRESSURE | VAR | BREAKPOINT | DEFUN | WS | LINECOMMENT | ID | OBRACKET | CBRACKET | CURLYOBRACKET | CURLYCBRACKET | EQUALS | DOT | SEMI | COLON | COMMA )
        int alt13 = 40;
        alt13 = dfa13.Predict(input);
        switch (alt13) 
        {
            case 1 :
                // LPMEDLexer.g:1:10: TERMINATEALL
                {
                	mTERMINATEALL(); 

                }
                break;
            case 2 :
                // LPMEDLexer.g:1:23: OpIncDec
                {
                	mOpIncDec(); 

                }
                break;
            case 3 :
                // LPMEDLexer.g:1:32: OpNegation
                {
                	mOpNegation(); 

                }
                break;
            case 4 :
                // LPMEDLexer.g:1:43: OpUnar
                {
                	mOpUnar(); 

                }
                break;
            case 5 :
                // LPMEDLexer.g:1:50: OpDivMul
                {
                	mOpDivMul(); 

                }
                break;
            case 6 :
                // LPMEDLexer.g:1:59: OpAddSub
                {
                	mOpAddSub(); 

                }
                break;
            case 7 :
                // LPMEDLexer.g:1:68: OpLogicalA
                {
                	mOpLogicalA(); 

                }
                break;
            case 8 :
                // LPMEDLexer.g:1:79: OpLogicalB
                {
                	mOpLogicalB(); 

                }
                break;
            case 9 :
                // LPMEDLexer.g:1:90: OpAnd
                {
                	mOpAnd(); 

                }
                break;
            case 10 :
                // LPMEDLexer.g:1:96: OpOr
                {
                	mOpOr(); 

                }
                break;
            case 11 :
                // LPMEDLexer.g:1:101: TYPE
                {
                	mTYPE(); 

                }
                break;
            case 12 :
                // LPMEDLexer.g:1:106: DBOOL
                {
                	mDBOOL(); 

                }
                break;
            case 13 :
                // LPMEDLexer.g:1:112: DEVICE
                {
                	mDEVICE(); 

                }
                break;
            case 14 :
                // LPMEDLexer.g:1:119: STATE
                {
                	mSTATE(); 

                }
                break;
            case 15 :
                // LPMEDLexer.g:1:125: ENDDEVICE
                {
                	mENDDEVICE(); 

                }
                break;
            case 16 :
                // LPMEDLexer.g:1:135: INT
                {
                	mINT(); 

                }
                break;
            case 17 :
                // LPMEDLexer.g:1:139: FLOAT
                {
                	mFLOAT(); 

                }
                break;
            case 18 :
                // LPMEDLexer.g:1:145: IF
                {
                	mIF(); 

                }
                break;
            case 19 :
                // LPMEDLexer.g:1:148: THEN
                {
                	mTHEN(); 

                }
                break;
            case 20 :
                // LPMEDLexer.g:1:153: ELSE
                {
                	mELSE(); 

                }
                break;
            case 21 :
                // LPMEDLexer.g:1:158: FOR
                {
                	mFOR(); 

                }
                break;
            case 22 :
                // LPMEDLexer.g:1:162: WHILE
                {
                	mWHILE(); 

                }
                break;
            case 23 :
                // LPMEDLexer.g:1:168: WAIT
                {
                	mWAIT(); 

                }
                break;
            case 24 :
                // LPMEDLexer.g:1:173: GO
                {
                	mGO(); 

                }
                break;
            case 25 :
                // LPMEDLexer.g:1:176: ENDPRESSURE
                {
                	mENDPRESSURE(); 

                }
                break;
            case 26 :
                // LPMEDLexer.g:1:188: VAR
                {
                	mVAR(); 

                }
                break;
            case 27 :
                // LPMEDLexer.g:1:192: BREAKPOINT
                {
                	mBREAKPOINT(); 

                }
                break;
            case 28 :
                // LPMEDLexer.g:1:203: DEFUN
                {
                	mDEFUN(); 

                }
                break;
            case 29 :
                // LPMEDLexer.g:1:209: WS
                {
                	mWS(); 

                }
                break;
            case 30 :
                // LPMEDLexer.g:1:212: LINECOMMENT
                {
                	mLINECOMMENT(); 

                }
                break;
            case 31 :
                // LPMEDLexer.g:1:224: ID
                {
                	mID(); 

                }
                break;
            case 32 :
                // LPMEDLexer.g:1:227: OBRACKET
                {
                	mOBRACKET(); 

                }
                break;
            case 33 :
                // LPMEDLexer.g:1:236: CBRACKET
                {
                	mCBRACKET(); 

                }
                break;
            case 34 :
                // LPMEDLexer.g:1:245: CURLYOBRACKET
                {
                	mCURLYOBRACKET(); 

                }
                break;
            case 35 :
                // LPMEDLexer.g:1:259: CURLYCBRACKET
                {
                	mCURLYCBRACKET(); 

                }
                break;
            case 36 :
                // LPMEDLexer.g:1:273: EQUALS
                {
                	mEQUALS(); 

                }
                break;
            case 37 :
                // LPMEDLexer.g:1:280: DOT
                {
                	mDOT(); 

                }
                break;
            case 38 :
                // LPMEDLexer.g:1:284: SEMI
                {
                	mSEMI(); 

                }
                break;
            case 39 :
                // LPMEDLexer.g:1:289: COLON
                {
                	mCOLON(); 

                }
                break;
            case 40 :
                // LPMEDLexer.g:1:295: COMMA
                {
                	mCOMMA(); 

                }
                break;

        }

    }


    protected DFA13 dfa13;
	private void InitializeCyclicDFAs()
	{
	    this.dfa13 = new DFA13(this);
	}

    const string DFA13_eotS =
        "\x01\uffff\x01\x1e\x01\x2b\x01\x2c\x01\uffff\x01\x1e\x01\x1d\x01"+
        "\uffff\x01\x2f\x02\uffff\x01\x1e\x01\uffff\x08\x1e\x01\x3c\x06\x1e"+
        "\x0b\uffff\x03\x1e\x03\uffff\x01\x1e\x02\uffff\x01\x1e\x01\x0c\x01"+
        "\x1e\x01\x4c\x08\x1e\x02\uffff\x04\x1e\x01\x59\x06\x1e\x01\x04\x01"+
        "\x0a\x01\x60\x01\uffff\x02\x1e\x01\x63\x06\x1e\x01\x6a\x02\x1e\x01"+
        "\uffff\x01\x6d\x03\x1e\x01\x71\x01\x72\x01\uffff\x02\x1e\x01\uffff"+
        "\x01\x60\x03\x1e\x01\uffff\x01\x78\x01\uffff\x01\x1e\x01\x7a\x01"+
        "\uffff\x03\x1e\x02\uffff\x01\x60\x01\x71\x02\x1e\x01\u0080\x01\uffff"+
        "\x01\u0081\x01\uffff\x01\x1e\x01\u0083\x01\x1e\x01\x60\x01\u0085"+
        "\x02\uffff\x01\x1e\x01\uffff\x01\x1e\x01\uffff\x06\x1e\x01\u008e"+
        "\x01\x1e\x01\uffff\x01\x1e\x01\u0091\x01\uffff";
    const string DFA13_eofS =
        "\u0092\uffff";
    const string DFA13_minS =
        "\x01\x09\x01\x65\x01\x2b\x01\x2d\x01\uffff\x01\x6f\x01\x2f\x01"+
        "\uffff\x01\x3d\x02\uffff\x01\x6e\x01\uffff\x01\x72\x01\x66\x01\x61"+
        "\x01\x6f\x01\x74\x01\x45\x01\x74\x01\x4e\x01\x2e\x01\x6c\x01\x61"+
        "\x01\x6f\x01\x41\x01\x72\x01\x65\x0b\uffff\x01\x72\x01\x75\x01\x65"+
        "\x03\uffff\x01\x74\x02\uffff\x01\x64\x01\x30\x01\x74\x01\x30\x01"+
        "\x6f\x01\x6c\x01\x72\x01\x6f\x01\x72\x01\x56\x01\x61\x01\x44\x02"+
        "\uffff\x01\x73\x01\x64\x02\x69\x01\x30\x01\x52\x01\x65\x01\x66\x01"+
        "\x6d\x01\x65\x01\x6e\x03\x30\x01\uffff\x01\x61\x01\x73\x01\x30\x01"+
        "\x6c\x01\x69\x01\x49\x01\x74\x01\x2e\x01\x65\x01\x30\x01\x6c\x01"+
        "\x74\x01\uffff\x01\x30\x01\x61\x01\x75\x01\x69\x02\x30\x01\uffff"+
        "\x01\x74\x01\x65\x01\uffff\x01\x30\x01\x6e\x01\x43\x01\x65\x01\uffff"+
        "\x01\x30\x01\uffff\x01\x65\x01\x30\x01\uffff\x01\x6b\x02\x6e\x02"+
        "\uffff\x02\x30\x01\x67\x01\x45\x01\x30\x01\uffff\x01\x30\x01\uffff"+
        "\x01\x70\x01\x30\x01\x61\x02\x30\x02\uffff\x01\x6f\x01\uffff\x01"+
        "\x74\x01\uffff\x01\x69\x01\x65\x01\x6e\x01\x5f\x01\x74\x01\x61\x01"+
        "\x30\x01\x6c\x01\uffff\x01\x6c\x01\x30\x01\uffff";
    const string DFA13_maxS =
        "\x01\x7e\x01\x72\x01\x2b\x01\x2d\x01\uffff\x01\x6f\x01\x2f\x01"+
        "\uffff\x01\x3d\x02\uffff\x01\x6e\x01\uffff\x01\x72\x01\x6e\x02\x6f"+
        "\x01\x74\x01\x45\x01\x74\x01\x4e\x01\x39\x01\x6e\x01\x68\x01\x6f"+
        "\x01\x41\x01\x72\x01\x65\x0b\uffff\x01\x72\x01\x75\x01\x65\x03\uffff"+
        "\x01\x74\x02\uffff\x01\x64\x01\x7a\x01\x74\x01\x7a\x01\x6f\x01\x6c"+
        "\x01\x72\x01\x6f\x01\x72\x01\x56\x01\x61\x01\x44\x02\uffff\x01\x73"+
        "\x01\x64\x02\x69\x01\x7a\x01\x52\x01\x65\x01\x66\x01\x6d\x01\x65"+
        "\x01\x6e\x03\x7a\x01\uffff\x01\x61\x01\x73\x01\x7a\x01\x6c\x01\x69"+
        "\x01\x49\x01\x74\x01\x2e\x01\x65\x01\x7a\x01\x6c\x01\x74\x01\uffff"+
        "\x01\x7a\x01\x61\x01\x75\x01\x69\x02\x7a\x01\uffff\x01\x74\x01\x65"+
        "\x01\uffff\x01\x7a\x01\x6e\x01\x43\x01\x65\x01\uffff\x01\x7a\x01"+
        "\uffff\x01\x65\x01\x7a\x01\uffff\x01\x6b\x02\x6e\x02\uffff\x02\x7a"+
        "\x01\x67\x01\x45\x01\x7a\x01\uffff\x01\x7a\x01\uffff\x01\x70\x01"+
        "\x7a\x01\x61\x02\x7a\x02\uffff\x01\x6f\x01\uffff\x01\x74\x01\uffff"+
        "\x01\x69\x01\x65\x01\x6e\x01\x5f\x01\x74\x01\x61\x01\x7a\x01\x6c"+
        "\x01\uffff\x01\x6c\x01\x7a\x01\uffff";
    const string DFA13_acceptS =
        "\x04\uffff\x01\x03\x02\uffff\x01\x07\x01\uffff\x01\x08\x01\x09"+
        "\x01\uffff\x01\x0a\x0f\uffff\x01\x1d\x01\x05\x01\x1f\x01\x20\x01"+
        "\x21\x01\x22\x01\x23\x01\x25\x01\x26\x01\x27\x01\x28\x03\uffff\x01"+
        "\x02\x01\x06\x01\x04\x01\uffff\x01\x1e\x01\x24\x0c\uffff\x01\x10"+
        "\x01\x11\x0e\uffff\x01\x12\x0c\uffff\x01\x18\x06\uffff\x01\x0b\x02"+
        "\uffff\x01\x15\x04\uffff\x01\x0f\x01\uffff\x01\x19\x02\uffff\x01"+
        "\x1a\x03\uffff\x01\x0c\x01\x13\x05\uffff\x01\x14\x01\uffff\x01\x17"+
        "\x05\uffff\x01\x0e\x01\x16\x01\uffff\x01\x1c\x01\uffff\x01\x0d\x08"+
        "\uffff\x01\x1b\x02\uffff\x01\x01";
    const string DFA13_specialS =
        "\u0092\uffff}>";
    static readonly string[] DFA13_transitionS = {
            "\x02\x1c\x02\uffff\x01\x1c\x12\uffff\x01\x1c\x01\x04\x04\uffff"+
            "\x01\x0a\x01\uffff\x01\x1f\x01\x20\x01\x1d\x01\x02\x01\x26\x01"+
            "\x03\x01\x23\x01\x06\x0a\x15\x01\x25\x01\x24\x01\x07\x01\x08"+
            "\x01\x07\x02\uffff\x01\x1e\x01\x1a\x01\x1e\x01\x12\x01\x14\x0d"+
            "\x1e\x01\x13\x02\x1e\x01\x19\x04\x1e\x04\uffff\x01\x1e\x01\uffff"+
            "\x01\x0b\x01\x10\x01\x1e\x01\x1b\x01\x16\x01\x0f\x01\x18\x01"+
            "\x1e\x01\x0e\x04\x1e\x01\x05\x01\x0d\x03\x1e\x01\x11\x01\x01"+
            "\x02\x1e\x01\x17\x03\x1e\x01\x21\x01\x0c\x01\x22\x01\x09",
            "\x01\x27\x02\uffff\x01\x29\x09\uffff\x01\x28",
            "\x01\x2a",
            "\x01\x2a",
            "",
            "\x01\x2d",
            "\x01\x2e",
            "",
            "\x01\x09",
            "",
            "",
            "\x01\x30",
            "",
            "\x01\x31",
            "\x01\x33\x07\uffff\x01\x32",
            "\x01\x35\x0a\uffff\x01\x34\x02\uffff\x01\x36",
            "\x01\x37",
            "\x01\x38",
            "\x01\x39",
            "\x01\x3a",
            "\x01\x3b",
            "\x01\x3d\x01\uffff\x0a\x15",
            "\x01\x3e\x01\uffff\x01\x3f",
            "\x01\x41\x06\uffff\x01\x40",
            "\x01\x42",
            "\x01\x43",
            "\x01\x44",
            "\x01\x45",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x01\x46",
            "\x01\x47",
            "\x01\x48",
            "",
            "",
            "",
            "\x01\x49",
            "",
            "",
            "\x01\x4a",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "\x01\x4b",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "\x01\x4d",
            "\x01\x4e",
            "\x01\x4f",
            "\x01\x50",
            "\x01\x51",
            "\x01\x52",
            "\x01\x53",
            "\x01\x54",
            "",
            "",
            "\x01\x55",
            "\x01\x56",
            "\x01\x57",
            "\x01\x58",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "\x01\x5a",
            "\x01\x5b",
            "\x01\x5c",
            "\x01\x5d",
            "\x01\x5e",
            "\x01\x5f",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "",
            "\x01\x61",
            "\x01\x62",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "\x01\x64",
            "\x01\x65",
            "\x01\x66",
            "\x01\x67",
            "\x01\x68",
            "\x01\x69",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "\x01\x6b",
            "\x01\x6c",
            "",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "\x01\x6e",
            "\x01\x6f",
            "\x01\x70",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "",
            "\x01\x73",
            "\x01\x74",
            "",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "\x01\x75",
            "\x01\x76",
            "\x01\x77",
            "",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "",
            "\x01\x79",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "",
            "\x01\x7b",
            "\x01\x7c",
            "\x01\x7d",
            "",
            "",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "\x01\x7e",
            "\x01\x7f",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "",
            "\x01\u0082",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "\x01\u0084",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "",
            "",
            "\x01\u0086",
            "",
            "\x01\u0087",
            "",
            "\x01\u0088",
            "\x01\u0089",
            "\x01\u008a",
            "\x01\u008b",
            "\x01\u008c",
            "\x01\u008d",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            "\x01\u008f",
            "",
            "\x01\u0090",
            "\x0a\x1e\x07\uffff\x1a\x1e\x04\uffff\x01\x1e\x01\uffff\x1a"+
            "\x1e",
            ""
    };

    static readonly short[] DFA13_eot = DFA.UnpackEncodedString(DFA13_eotS);
    static readonly short[] DFA13_eof = DFA.UnpackEncodedString(DFA13_eofS);
    static readonly char[] DFA13_min = DFA.UnpackEncodedStringToUnsignedChars(DFA13_minS);
    static readonly char[] DFA13_max = DFA.UnpackEncodedStringToUnsignedChars(DFA13_maxS);
    static readonly short[] DFA13_accept = DFA.UnpackEncodedString(DFA13_acceptS);
    static readonly short[] DFA13_special = DFA.UnpackEncodedString(DFA13_specialS);
    static readonly short[][] DFA13_transition = DFA.UnpackEncodedStringArray(DFA13_transitionS);

    protected class DFA13 : DFA
    {
        public DFA13(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 13;
            this.eot = DFA13_eot;
            this.eof = DFA13_eof;
            this.min = DFA13_min;
            this.max = DFA13_max;
            this.accept = DFA13_accept;
            this.special = DFA13_special;
            this.transition = DFA13_transition;

        }

        override public string Description
        {
            get { return "1:1: Tokens : ( TERMINATEALL | OpIncDec | OpNegation | OpUnar | OpDivMul | OpAddSub | OpLogicalA | OpLogicalB | OpAnd | OpOr | TYPE | DBOOL | DEVICE | STATE | ENDDEVICE | INT | FLOAT | IF | THEN | ELSE | FOR | WHILE | WAIT | GO | ENDPRESSURE | VAR | BREAKPOINT | DEFUN | WS | LINECOMMENT | ID | OBRACKET | CBRACKET | CURLYOBRACKET | CURLYCBRACKET | EQUALS | DOT | SEMI | COLON | COMMA );"; }
        }

    }

 
    
}
}